"""
@name : 基础练习作业
@author : gushuai
@projectname : Tools
"""
# 1.实现1-100之和
# a = 0
# i = 1
# while i <= 100:
#     a += i
#     i += 1
# print(a)

#2.列表去重并从大到小排序
# list = [2,3,56,78,2,4,56,98,12,100]
# set = set(list)
# list1 = []
# for i in set:
#     list1.append(i)
# sort = sorted(list1,reverse = True)
# print(sort)

#3.如何在函数内部修改全局变量
# 用global后面接一个变量，修改变量的值即可

#4.如何跨模块共享全局变量
# 除了函数内部，python的变量本身作用域就是全局的。
# 不同的模块互相导入时，将变量一同导入就行了，而函数内修改这些全局变量时需要先用global修饰变量名

#5、python数据类型有哪些
# Python3 中有六个标准的数据类型：
# Number（数字）数字又包括整型，浮点型，复数型，布尔型
# String（字符串）
# List（列表）
# Tuple（元组）
# Set（集合）
# Dictionary（字典）

#6、python中生成随机整数(1-10)，随机小数(1-10), 0-1之间小数的方法
# import random
# a = random.randint(1,10) 生成随机整数(1-10)
# b = random.random()  生成随机小数(0-1)
# c = random.uniform(1,10) 生成随机小数(1-10)
# print(a,b,c)

#7、python2与python3的区别，列出5个
# 1.输入和输出
#python2:print "abc"    #python2:  input默认接收整型数据，str类型要用引号包起来， 用raw_input函数接收字符串。
#python3: print("abc")   #python3： input函数接收  获得输入为str类型。
#2、运算符
#整除
#python3 中 / 表示真除
#python2中  /  整数相处只能获取商值， 浮点型数据相除才能获得真实数据
#3.整型数据
#python2中整型区分int 和long
#python3中都为int类型
#4、字符编码
#python2 默认编码是ascii码
#python3 默认是utf-8
#5、模块导入
#python3  默认以绝对导入方式导入模块
#python2  默认是相对导入

#8、python中哪些是可变数据类型，哪些是不可变数据类型，为什么
# int str tuple是不可变的，list set dict是可变的
# 因为列表 集合 字典的value值改变了，但是id值不变，所以是可变数据类型
# 反之，其它数据类型就是不可变的

#9、统计字符串中每个单词出现的次数
#用count()
# str = 'I love you,I love you,you are pretty'
# print(str.count('you'))

#10、Python实现，给定一个字符串，找到字符串中第一个重复的字符
# str = 'fhsfsdbvhgfeyfbhsk'
# str1 = ''
# for i in str:
#     if str.count(i) != 1:
#         str1 += i
# print(str1[0])

#11、什么是pep 8
# PEP8是一个编程规范，内容是一些关于如何让你的程序更具可读性的建议。
# 可以安装flake8语法检查工具

#12、python里如何赋值、浅拷贝、深拷贝的区别
#赋值的话相当于两个字典是一样的，假设b=a,这样的话，a做出什么改动，b也会跟着a一起改
#浅拷贝就只是拷贝第一层数据，b=a.copy() a做出什么改动，b只会改第一层的数据
#深拷贝就是递归拷贝所有层的数据,b=copy.deepcopy(),a无论怎么改动，b也只是一开始深拷贝a的样子

#13、简述python的内存管理机制
#python的内存管理机制有引用计数，垃圾回收，内存池机制
#引用计数：
#python内部使用引用计数，来保持追踪内存中的对象，Python内部记录了对象有多少个引用，即引用计数，
#当对象被创建时就创建了一个引用计数，当对象不再需要时，这个对象的引用计数为0时，它被垃圾回收
#垃圾回收：
# 1、当内存中有不再使用的部分时，垃圾收集器就会把他们清理掉。它会去检查那些引用计数为0的对象，然后清除其在内存的空间。
# 当然除了引用计数为0的会被清除，还有一种情况也会被垃圾收集器清掉：当两个对象相互引用时，他们本身其他的引用已经为0了。
# 2、垃圾回收机制还有一个循环垃圾回收器, 确保释放循环引用对象(a引用b, b引用a, 导致其引用计数永远不为0)。
#内存池机制
# Python中所有小于256个字节的对象都使用pymalloc实现的分配器，而大的对象则使用系统的 malloc。
# 另外Python对象，如整数，浮点数和List，都有其独立的私有内存池，对象间不共享他们的内存池。
# 也就是说如果你分配又释放了大量的整数，用于缓存这些整数的内存就不能再分配给浮点数。

#14、重复接收用户输入的一个字符串，如果是正整数, 就输出结果，否则一直输入
# try:
#     while True:
#         str = input()
#         if str.isdigit():
#             if int(str) > 0:
#                 print(str)
#                 break
#             else:
#                 print("请输出正整数")
#                 continue
#         else:
#             print("请输入整数")
#             continue
#
# except ValueError as e:
#     print("输入类型错误",e)

#15.以左下三角的形式输出1~9乘法口诀
# j = 1
# while j <= 9:
#     i = 1
#     while i <= j:
#         print(f'{i} * {j} = {i*j}',end='\t')
#         i += 1
#     print()
#     j += 1

#16、实现n个数的介乘
# n! = 1*2*3*4*5...*n
# f(n) = n * f(n-1)
# def jiecheng(n):
#     # 定义出口
#     if n == 1:
#         return 1
#     else:
#         return n*jiecheng(n-1)
# b = jiecheng(6)
# print(b)

#17、给定一个列表如[1,2,3,4,5,6] ，指定任意一个数字如6 ，快速的计算出列表里哪两个数相加为6，若相加都不为6则输出提示。
# list = [1,2,3,4,5,6]
# list1 = []
# list2 = []
# for i in list:
#     if 6-i in list and (6-i) != i:
#         list1.append(i)
#         list1.append(6-i)
# set = set(list1)
# for j in set:
#     list2.append(j)
#
# else:
#     print("没有相加为6的两个数")
# print(list2)

#18、打印出所有100到999的"水仙花数"，所谓"水仙花数"是指一个三位数，其各位数字立方和等于该数本身。
# 例如：153是一个"水仙花数"，因为153=1的三次方＋5的三次方＋3的三次方。
# list = []
# list2 = []
# for i in range(100,999):
#     if i == (i//100)**3 + (i//10%10)**3 + (i%10)**3:
#         list.append(i)
#     else:
#         list2.append(i)
# print(list)

#19、用python实现冒泡排序
# list1 = [1,2,4,6,3,5,9,8,7]
# for i in range(len(list1)-1): #循环遍历从0开始到倒数第二个元素下标
#     for j in range(len(list1)-1-i):  #循环遍历从0开始，每次循环将最大数放到最末尾
#         if list1[j] > list1[j+1]:  #判断两个相邻数的大小，大的往后面排，小的往前面排
#             list1[j],list1[j+1] = list1[j+1],list1[j]
# print(list1)
#20、用python实现快速排序
# def quicksort(array):
#     if len(array) < 2:
#         return array
#     else:
#         pivot = array[0]
#         less = [i for i in array[1:] if i<= pivot]
#         greater = [i for i in array[1:] if i > pivot]
#         return quicksort(less) + [pivot] + quicksort(greater)
# b = quicksort([5,11,3,9,8,2,6,7])
# print(b)
